"""
统一日志模块接口示例

演示如何使用统一日志模块的所有核心功能，包括：
- 基础日志记录
- 上下文日志
- 性能监控
- 错误处理
- 同步接口
- 配置接口
- 环境变量配置
- 结构化日志
- 批量处理

运行方式:
    python 接口示例.py

查看日志:
    异步日志: logs/app.log
    同步日志: logs/sync_app.log
"""

import os
import sys
import time
import random
import logging
from typing import List, Dict, Any

# 添加当前目录到Python路径，确保模块导入
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from unified_logger import logger, sync_logger

class InterfaceDemo:
    """接口演示类
    
    展示统一日志模块的所有核心功能用法，每个方法演示一个特定功能
    """
    
    def __init__(self) -> None:
        """初始化演示类"""
        self.processor_id = f"demo_{int(time.time())}"
        logger.info(f"[{self.processor_id}] 初始化演示类")
    
    def demo_basic_logging(self) -> None:
        """演示基础日志记录功能
        
        展示不同日志级别的基本使用方法
        """
        print("\n📋 1. 基础日志记录")
        print("-" * 30)
        
        logger.debug("这是调试信息")
        logger.info("这是信息消息")
        logger.warning("这是警告消息")
        
        try:
            result = 10 / 0
        except ZeroDivisionError as e:
            logger.error(f"计算错误: {str(e)}")
        
        print("✅ 基础日志记录完成")
    
    def demo_context_logging(self) -> None:
        """演示上下文日志功能
        
        展示如何在业务上下文中使用日志记录
        """
        print("\n📊 2. 上下文日志")
        print("-" * 30)
        
        def inner_function(data: str) -> str:
            """内部处理函数"""
            logger.debug(f"处理数据: {data}")
            return data.upper()
        
        items = ["apple", "banana", "cherry"]
        for item in items:
            logger.info(f"处理项目: {item}")
            processed = inner_function(item)
            logger.debug(f"结果: {processed}")
        
        print("✅ 上下文日志演示完成")
    
    def demo_performance_monitoring(self) -> None:
        """演示性能监控功能
        
        展示如何记录性能相关日志和指标
        """
        print("\n⚡ 3. 性能监控")
        print("-" * 30)
        
        # 性能测试
        start_time = time.time()
        for i in range(5):
            logger.info(f"性能测试消息 {i+1}/5")
        
        elapsed = time.time() - start_time
        logger.info(f"5条日志耗时: {elapsed:.3f}秒")
        
        # 等待异步处理完成
        time.sleep(0.2)
        
        print("✅ 性能监控演示完成")
    
    def demo_error_handling(self) -> None:
        """演示错误处理功能
        
        展示如何正确处理异常和错误日志
        """
        print("\n🚨 4. 错误处理")
        print("-" * 30)
        
        def risky_operation() -> str:
            """模拟有风险的业务操作"""
            if random.random() < 0.5:
                raise ValueError("模拟业务错误")
            return "成功"
        
        for i in range(3):
            try:
                logger.info(f"尝试操作 {i+1}/3")
                result = risky_operation()
                logger.info(f"操作成功: {result}")
            except ValueError as e:
                logger.warning(f"业务错误: {str(e)}")
            except Exception as e:
                logger.error(f"系统错误: {str(e)}", alert=True)
        
        print("✅ 错误处理演示完成")
    
    def demo_sync_interface(self) -> None:
        """演示同步日志接口
        
        展示同步日志器的使用方法
        """
        print("\n🔄 5. 同步接口")
        print("-" * 30)
        
        # 同步日志器使用
        sync_logger.info("这是同步日志消息")
        sync_logger.warning("同步警告", alert=True)
        
        try:
            raise RuntimeError("同步错误")
        except RuntimeError as e:
            sync_logger.error("同步错误处理", exc_info=e)
        
        print("✅ 同步接口演示完成")
    
    def demo_configuration_interface(self) -> None:
        """演示配置接口
        
        展示如何动态调整日志配置
        """
        print("\n⚙️ 6. 配置接口")
        print("-" * 30)
        
        # 获取当前日志级别
        current_level = logger.logger.level
        level_name = logging.getLevelName(current_level)
        print(f"当前日志级别: {level_name}")
        
        # 动态更新日志级别
        print("更新日志级别为DEBUG...")
        logger.update_log_level("DEBUG")
        
        # 测试DEBUG级别日志
        logger.debug("这是一条DEBUG级别的日志消息")
        
        # 恢复原始级别
        logger.update_log_level("INFO")
        print(f"恢复日志级别为: {level_name}")
        
        print("✅ 配置接口演示完成")
    
    def demo_environment_config(self) -> None:
        """演示环境变量配置
        
        展示如何通过环境变量配置日志行为
        """
        print("\n🌍 7. 环境变量配置")
        print("-" * 30)
        
        # 查看当前环境变量
        log_level = os.getenv('LOG_LEVEL', 'INFO')
        log_dir = os.getenv('LOG_DIR', 'logs')
        retention_days = os.getenv('LOG_RETENTION_DAYS', '7')
        
        print(f"环境变量LOG_LEVEL: {log_level}")
        print(f"环境变量LOG_DIR: {log_dir}")
        print(f"环境变量LOG_RETENTION_DAYS: {retention_days}")
        
        logger.info("当前日志级别由环境变量控制")
        
        print("✅ 环境变量配置演示完成")
    
    def demo_structured_logging(self) -> None:
        """演示结构化日志
        
        展示如何记录结构化的业务数据
        """
        print("\n🏗️ 8. 结构化日志")
        print("-" * 30)
        
        # 记录结构化数据
        user_data = {
            "user_id": 12345,
            "username": "alice",
            "action": "login",
            "ip": "192.168.1.100",
            "timestamp": time.time()
        }
        
        logger.info(f"结构化日志: {user_data}")
        
        # 记录业务指标
        metrics = {
            "request_count": 100,
            "response_time": 0.123,
            "error_rate": 0.02,
            "memory_usage": 64.5
        }
        
        logger.info(f"性能指标: {metrics}")
        
        print("✅ 结构化日志演示完成")
    
    def demo_batch_processing(self) -> None:
        """演示批量处理
        
        展示如何在批量处理中使用日志
        """
        print("\n📦 9. 批量处理")
        print("-" * 30)
        
        def process_batch(items: List[str]) -> List[str]:
            """批量处理函数"""
            logger.info(f"开始批量处理 {len(items)} 个项目")
            
            results = []
            for i, item in enumerate(items):
                logger.debug(f"处理第 {i+1} 个项目: {item}")
                
                # 模拟处理
                time.sleep(0.001)
                results.append(item.upper())
                
                if (i + 1) % 5 == 0:
                    logger.info(f"处理进度: {i+1}/{len(items)}")
            
            logger.info("批量处理完成")
            return results
        
        items = [f"item_{i}" for i in range(10)]
        processed = process_batch(items)
        logger.info(f"处理结果: {len(processed)} 个项目")
        
        print("✅ 批量处理演示完成")
    
    def run_all_demos(self) -> None:
        """运行所有演示
        
        依次执行所有功能演示，展示完整功能集
        """
        print("🚀 统一日志模块接口演示")
        print("=" * 50)
        
        # 按顺序执行所有演示
        demos = [
            self.demo_basic_logging,
            self.demo_context_logging,
            self.demo_performance_monitoring,
            self.demo_error_handling,
            self.demo_sync_interface,
            self.demo_configuration_interface,
            self.demo_environment_config,
            self.demo_structured_logging,
            self.demo_batch_processing
        ]
        
        for demo in demos:
            try:
                demo()
                time.sleep(0.1)  # 演示间隔
            except Exception as e:
                print(f"❌ 演示失败: {e}")
        
        print("\n🎉 所有接口演示完成！")
        print("请查看 logs/app.log 和 logs/sync_app.log 中的日志内容")

def main() -> None:
    """主函数
    
    设置测试环境并运行演示
    """
    # 设置环境变量进行测试
    os.environ['LOG_LEVEL'] = 'DEBUG'
    
    demo = InterfaceDemo()
    demo.run_all_demos()

if __name__ == "__main__":
    main()